#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

/**
 * 从 tools.json 文件读取工具配置
 */
function getToolConfigs() {
  try {
    const toolsFilePath = path.join(__dirname, "tools.json");
    if (!fs.existsSync(toolsFilePath)) {
      console.error(`错误：工具配置文件不存在: ${toolsFilePath}`);
      process.exit(1);
    }

    const toolsContent = fs.readFileSync(toolsFilePath, "utf8");
    const toolsConfig = JSON.parse(toolsContent);

    if (!toolsConfig.tools || toolsConfig.tools.length === 0) {
      console.error(`错误：工具配置文件为空或格式不正确: ${toolsFilePath}`);
      process.exit(1);
    }

    return toolsConfig.tools;
  } catch (error) {
    console.error(`错误：读取或解析工具配置文件失败: ${error.message}`);
    process.exit(1);
  }
}

/**
 * 递归生成源文件到目标文件的映射关系
 * 只有 cursor 工具类型才将 .md 转换为 .mdc
 * @param {string} sourceDir - 源目录路径
 * @param {string} targetDir - 目标目录路径
 * @param {string} toolType - 工具类型
 * @returns {Array} 文件映射数组，每个元素包含 {sourcePath, targetPath, fileName}
 */
function generateFileMapping(sourceDir, targetDir, toolType) {
  const fileMapping = [];
  const items = fs.readdirSync(sourceDir);

  for (const item of items) {
    const sourcePath = path.join(sourceDir, item);
    const stat = fs.statSync(sourcePath);

    if (stat.isDirectory()) {
      // 递归处理子目录
      const targetSubDir = path.join(targetDir, item);
      const subMapping = generateFileMapping(
        sourcePath,
        targetSubDir,
        toolType
      );
      fileMapping.push(...subMapping);
    } else if (stat.isFile()) {
      // 确定目标文件名（只有 cursor 工具类型才将 .md 转换为 .mdc）
      let targetFileName = item;
      if (path.extname(item) === ".md" && toolType === "cursor") {
        targetFileName = path.basename(item, ".md") + ".mdc";
      }

      const targetPath = path.join(targetDir, targetFileName);

      fileMapping.push({
        sourcePath,
        targetPath,
        fileName: targetFileName,
        originalFileName: item,
      });
    }
  }

  return fileMapping;
}

/**
 * 根据文件映射执行复制操作
 * @param {Array} fileMapping - 文件映射数组
 */
function copyFilesFromMapping(fileMapping) {
  for (const mapping of fileMapping) {
    const { sourcePath, targetPath, fileName, originalFileName } = mapping;

    // 确保目标目录存在
    const targetDir = path.dirname(targetPath);
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }

    // 复制文件
    fs.copyFileSync(sourcePath, targetPath);
    console.log(`已复制: ${originalFileName} -> ${fileName}`);
  }
}

/**
 * 递归复制目录内容，支持条件文件扩展名转换
 * 只有 cursor 工具类型才将 .md 转换为 .mdc
 * @param {string} sourceDir - 源目录路径
 * @param {string} targetDir - 目标目录路径
 * @param {string} toolType - 工具类型
 */
function copyRulesDirectory(sourceDir, targetDir, toolType) {
  // 第一步：生成文件映射
  const fileMapping = generateFileMapping(sourceDir, targetDir, toolType);

  // 第二步：根据映射执行复制操作
  copyFilesFromMapping(fileMapping);
}

function main() {
  // Get command line arguments
  const args = process.argv.slice(2);

  // Get supported tools from tools.json file
  const toolConfigs = getToolConfigs();
  const validToolTypes = toolConfigs.map((t) => t.tool_name);

  // Parse command line arguments
  let projectDir = null;
  let toolType = null;
  let showHelp = false;

  for (let i = 0; i < args.length; i++) {
    if (args[i] === "-p" && i + 1 < args.length) {
      projectDir = args[i + 1];
      i++; // Skip next argument
    } else if (args[i] === "-t" && i + 1 < args.length) {
      toolType = args[i + 1];
      i++; // Skip next argument
    } else if (args[i] === "-h" || args[i] === "--help") {
      showHelp = true;
    } else if (args[i] === "-V" || args[i] === "--version") {
      console.log("AI 编程助手规则安装程序 v1.0.0");
      process.exit(0);
    }
  }

  // Show help if requested
  if (showHelp) {
    console.log("AI 编程助手规则安装程序");
    console.log("");
    console.log("用法:");
    console.log("  ./install -p <项目目录> -t <工具类型>");
    console.log("");
    console.log("参数:");
    console.log("  -p <项目目录>    目标项目目录路径");
    console.log(
      "  -t <工具类型>    AI工具类型 (" + validToolTypes.join(", ") + ")"
    );
    console.log("  -h, --help      显示此帮助信息");
    console.log("");
    console.log("工具类型说明:");

    // 动态生成工具类型说明
    for (const tool of toolConfigs) {
      const targetPath = `.${tool.tool_name}/${tool.target}/`;
      if (tool.tool_name === "cursor") {
        console.log(
          `  ${tool.tool_name.padEnd(
            15
          )} 创建 ${targetPath} 目录，将 .md 文件转换为 .mdc`
        );
      } else {
        console.log(
          `  ${tool.tool_name.padEnd(
            15
          )} 创建 ${targetPath} 目录，保持 .md 扩展名`
        );
      }
    }
    console.log("");
    console.log("示例:");
    console.log(`  ./install -p /path/to/project -t ${validToolTypes[0]}`);
    console.log(
      "  ./install -p . -t " + validToolTypes[1] || validToolTypes[0]
    );
    if (validToolTypes.length > 2) {
      console.log(
        `  ./install -p ~/my-project -t ${
          validToolTypes[validToolTypes.length - 1]
        }`
      );
    }
    console.log("");
    console.log("说明:");
    console.log(
      "  该程序会将 rules/ 目录及其所有子目录复制到指定的项目目录中。"
    );
    console.log("  目标目录结构: <项目目录>/.<工具类型>/<target目录>/");
    console.log("  <target目录> 由 tools.json 文件中的 target 字段定义。");
    console.log(
      "  只有 cursor 工具类型会将 .md 文件重命名为 .mdc，其他工具保持原扩展名。"
    );
    process.exit(0);
  }

  // Validate arguments
  if (!projectDir || !toolType) {
    console.error("错误：缺少必需参数");
    console.error("用法: ./install -p <项目目录> -t <工具类型>");
    console.error("工具类型: " + validToolTypes.join(", "));
    console.error(
      `示例: ./install -p /path/to/project -t ${validToolTypes[0]}`
    );
    console.error("使用 -h 查看详细帮助信息");
    process.exit(1);
  }

  // Validate tool type
  if (!validToolTypes.includes(toolType)) {
    console.error(
      `错误：无效的工具类型 '${toolType}'，有效类型: ${validToolTypes.join(
        ", "
      )}`
    );
    process.exit(1);
  }

  // Find the tool configuration for the selected tool type
  const toolConfig = toolConfigs.find((t) => t.tool_name === toolType);
  if (!toolConfig) {
    // This should not happen due to the validation above, but as a safeguard
    console.error(`错误：未找到工具 '${toolType}' 的配置。`);
    process.exit(1);
  }

  const targetDir = path.resolve(projectDir);
  const sourceRulesDir = path.join(__dirname, "..", "rules");
  const targetRulesDir = path.join(
    targetDir,
    `.${toolType}`,
    toolConfig.target
  );

  // Check if source rules directory exists
  if (!fs.existsSync(sourceRulesDir)) {
    console.error(`错误：源规则目录不存在: ${sourceRulesDir}`);
    process.exit(1);
  }

  // Check if target directory exists
  if (!fs.existsSync(targetDir)) {
    console.error(`错误：目标目录不存在: ${targetDir}`);
    process.exit(1);
  }

  try {
    // Create tool-specific directory if it doesn't exist
    const toolDir = path.join(targetDir, `.${toolType}`);
    if (!fs.existsSync(toolDir)) {
      fs.mkdirSync(toolDir, { recursive: true });
      console.log(`创建目录: ${toolDir}`);
    }

    // Create rules directory if it doesn't exist
    if (!fs.existsSync(targetRulesDir)) {
      fs.mkdirSync(targetRulesDir, { recursive: true });
      console.log(`创建目录: ${targetRulesDir}`);
    }

    // Copy files from source rules to target rules
    copyRulesDirectory(sourceRulesDir, targetRulesDir, toolType);

    console.log(`成功复制规则文件从 ${sourceRulesDir} 到 ${targetRulesDir}`);
    if (toolType === "cursor") {
      console.log("所有 .md 文件已转换为 .mdc 文件（cursor 工具类型）");
    } else {
      console.log("文件已复制，保持原有 .md 扩展名");
    }
  } catch (error) {
    console.error(`错误: ${error.message}`);
    process.exit(1);
  }
}

// Run main function only if this script is executed directly
if (require.main === module) {
  main();
}

module.exports = {
  getToolConfigs,
  generateFileMapping,
  copyFilesFromMapping,
};
